package com.gitee.qdbp.general.common.api.reusable.model;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import com.gitee.qdbp.general.common.enums.UsingState;

/**
 * 基础树形数据查询类
 *
 * @author zhh
 * @version 180514
 */
public class SimpleTreeWhere extends SimpleTreeBean {

    /** 版本序列号 **/
    private static final long serialVersionUID = 1L;

    /** 主键列表 **/
    private List<String> ids;

    /** 主键前模匹配条件 **/
    private String idStarts;

    /** 主键后模匹配条件 **/
    private String idEnds;

    /** 主键模糊查询条件 **/
    private String idLike;

    /** 租户编号空值/非空值查询 **/
    private Boolean tenantCodeIsNull;

    /** 租户编号前模匹配条件 **/
    private String tenantCodeStarts;

    /** 租户编号后模匹配条件 **/
    private String tenantCodeEnds;

    /** 租户编号模糊查询条件 **/
    private String tenantCodeLike;

    /** 使用场景空值/非空值查询 **/
    private Boolean sceneTypeIsNull;

    /** 使用场景前模匹配条件 **/
    private String sceneTypeStarts;

    /** 使用场景后模匹配条件 **/
    private String sceneTypeEnds;

    /** 使用场景模糊查询条件 **/
    private String sceneTypeLike;

    /** 节点编号列表 **/
    private List<String> nodeCodes;

    /** 节点编号前模匹配条件 **/
    private String nodeCodeStarts;

    /** 节点编号后模匹配条件 **/
    private String nodeCodeEnds;

    /** 节点编号模糊查询条件 **/
    private String nodeCodeLike;

    /** 节点名称空值/非空值查询 **/
    private Boolean nodeTextIsNull;

    /** 节点名称前模匹配条件 **/
    private String nodeTextStarts;

    /** 节点名称后模匹配条件 **/
    private String nodeTextEnds;

    /** 节点名称模糊查询条件 **/
    private String nodeTextLike;

    /** 上级编号空值/非空值查询 **/
    private Boolean parentCodeIsNull;

    /** 上级编号列表 **/
    private List<String> parentCodes;

    /** 上级编号前模匹配条件 **/
    private String parentCodeStarts;

    /** 上级编号后模匹配条件 **/
    private String parentCodeEnds;

    /** 上级编号模糊查询条件 **/
    private String parentCodeLike;

    /** 排序号(越小越靠前)空值/非空值查询 **/
    private Boolean sortIndexIsNull;

    /** 最小排序号(越小越靠前) **/
    private Integer sortIndexMin;

    /** 最大排序号(越小越靠前) **/
    private Integer sortIndexMax;

    /** 级数(从1开始)空值/非空值查询 **/
    private Boolean levelIndexIsNull;

    /** 最小级数(从1开始) **/
    private Integer levelIndexMin;

    /** 最大级数(从1开始) **/
    private Integer levelIndexMax;

    /** 是否叶子节点空值/非空值查询 **/
    private Boolean leafIsNull;

    /** 创建人ID空值/非空值查询 **/
    private Boolean creatorIdIsNull;

    /** 创建人ID前模匹配条件 **/
    private String creatorIdStarts;

    /** 创建人ID后模匹配条件 **/
    private String creatorIdEnds;

    /** 创建人ID模糊查询条件 **/
    private String creatorIdLike;

    /** 最小创建时间 **/
    private Date createTimeMin;

    /** 最大创建时间 **/
    private Date createTimeMax;

    /** 最小创建时间 **/
    private Date createTimeMinWithDay;

    /** 最大创建时间 **/
    private Date createTimeMaxWithDay;

    /** 选项空值/非空值查询 **/
    private Boolean optionsIsNull;

    /** 启用状态(1.正常|2.未启用)空值/非空值查询 **/
    private Boolean usingStateIsNull;

    /** 启用状态(1.正常|2.未启用)列表 **/
    private List<UsingState> usingStates;

    /** 获取主键列表 **/
    public List<String> getIds() {
        return ids;
    }

    /** 设置主键列表 **/
    public void setIds(List<String> ids) {
        this.ids = ids;
    }

    /** 增加主键 **/
    public void addId(String... ids) {
        if (this.ids == null) {
            this.ids = new ArrayList<>();
        }
        this.ids.addAll(Arrays.asList(ids));
    }

    /** 获取主键前模匹配条件 **/
    public String getIdStarts() {
        return idStarts;
    }

    /** 设置主键前模匹配条件 **/
    public void setIdStarts(String idStarts) {
        this.idStarts = idStarts;
    }

    /** 获取主键后模匹配条件 **/
    public String getIdEnds() {
        return idEnds;
    }

    /** 设置主键后模匹配条件 **/
    public void setIdEnds(String idEnds) {
        this.idEnds = idEnds;
    }

    /** 获取主键模糊查询条件 **/
    public String getIdLike() {
        return idLike;
    }

    /** 设置主键模糊查询条件 **/
    public void setIdLike(String idLike) {
        this.idLike = idLike;
    }

    /** 判断租户编号是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getTenantCodeIsNull() {
        return tenantCodeIsNull;
    }

    /**
     * 设置租户编号空值查询(true:空值查询|false:非空值查询)
     *
     * @param tenantCodeIsNull 租户编号空值查询
     * @deprecated 该字段为非空字段
     */
    @Deprecated
    public void setTenantCodeIsNull(Boolean tenantCodeIsNull) {
        this.tenantCodeIsNull = tenantCodeIsNull;
    }

    /** 获取租户编号前模匹配条件 **/
    public String getTenantCodeStarts() {
        return tenantCodeStarts;
    }

    /** 设置租户编号前模匹配条件 **/
    public void setTenantCodeStarts(String tenantCodeStarts) {
        this.tenantCodeStarts = tenantCodeStarts;
    }

    /** 获取租户编号后模匹配条件 **/
    public String getTenantCodeEnds() {
        return tenantCodeEnds;
    }

    /** 设置租户编号后模匹配条件 **/
    public void setTenantCodeEnds(String tenantCodeEnds) {
        this.tenantCodeEnds = tenantCodeEnds;
    }

    /** 获取租户编号模糊查询条件 **/
    public String getTenantCodeLike() {
        return tenantCodeLike;
    }

    /** 设置租户编号模糊查询条件 **/
    public void setTenantCodeLike(String tenantCodeLike) {
        this.tenantCodeLike = tenantCodeLike;
    }

    /** 判断使用场景是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getSceneTypeIsNull() {
        return sceneTypeIsNull;
    }

    /**
     * 设置使用场景空值查询(true:空值查询|false:非空值查询)
     *
     * @param sceneTypeIsNull 使用场景空值查询
     * @deprecated 该字段为非空字段
     */
    @Deprecated
    public void setSceneTypeIsNull(Boolean sceneTypeIsNull) {
        this.sceneTypeIsNull = sceneTypeIsNull;
    }

    /** 获取使用场景前模匹配条件 **/
    public String getSceneTypeStarts() {
        return sceneTypeStarts;
    }

    /** 设置使用场景前模匹配条件 **/
    public void setSceneTypeStarts(String sceneTypeStarts) {
        this.sceneTypeStarts = sceneTypeStarts;
    }

    /** 获取使用场景后模匹配条件 **/
    public String getSceneTypeEnds() {
        return sceneTypeEnds;
    }

    /** 设置使用场景后模匹配条件 **/
    public void setSceneTypeEnds(String sceneTypeEnds) {
        this.sceneTypeEnds = sceneTypeEnds;
    }

    /** 获取使用场景模糊查询条件 **/
    public String getSceneTypeLike() {
        return sceneTypeLike;
    }

    /** 设置使用场景模糊查询条件 **/
    public void setSceneTypeLike(String sceneTypeLike) {
        this.sceneTypeLike = sceneTypeLike;
    }

    /** 获取节点编号列表 **/
    public List<String> getNodeCodes() {
        return nodeCodes;
    }

    /** 设置节点编号列表 **/
    public void setNodeCodes(List<String> nodeCodes) {
        this.nodeCodes = nodeCodes;
    }

    /** 增加节点编号 **/
    public void addNodeCode(String... nodeCodes) {
        if (this.nodeCodes == null) {
            this.nodeCodes = new ArrayList<>();
        }
        this.nodeCodes.addAll(Arrays.asList(nodeCodes));
    }

    /** 获取节点编号前模匹配条件 **/
    public String getNodeCodeStarts() {
        return nodeCodeStarts;
    }

    /** 设置节点编号前模匹配条件 **/
    public void setNodeCodeStarts(String nodeCodeStarts) {
        this.nodeCodeStarts = nodeCodeStarts;
    }

    /** 获取节点编号后模匹配条件 **/
    public String getNodeCodeEnds() {
        return nodeCodeEnds;
    }

    /** 设置节点编号后模匹配条件 **/
    public void setNodeCodeEnds(String nodeCodeEnds) {
        this.nodeCodeEnds = nodeCodeEnds;
    }

    /** 获取节点编号模糊查询条件 **/
    public String getNodeCodeLike() {
        return nodeCodeLike;
    }

    /** 设置节点编号模糊查询条件 **/
    public void setNodeCodeLike(String nodeCodeLike) {
        this.nodeCodeLike = nodeCodeLike;
    }

    /** 判断节点名称是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getNodeTextIsNull() {
        return nodeTextIsNull;
    }

    /**
     * 设置节点名称空值查询(true:空值查询|false:非空值查询)
     *
     * @param nodeTextIsNull 节点名称空值查询
     * @deprecated 该字段为非空字段
     */
    @Deprecated
    public void setNodeTextIsNull(Boolean nodeTextIsNull) {
        this.nodeTextIsNull = nodeTextIsNull;
    }

    /** 获取节点名称前模匹配条件 **/
    public String getNodeTextStarts() {
        return nodeTextStarts;
    }

    /** 设置节点名称前模匹配条件 **/
    public void setNodeTextStarts(String nodeTextStarts) {
        this.nodeTextStarts = nodeTextStarts;
    }

    /** 获取节点名称后模匹配条件 **/
    public String getNodeTextEnds() {
        return nodeTextEnds;
    }

    /** 设置节点名称后模匹配条件 **/
    public void setNodeTextEnds(String nodeTextEnds) {
        this.nodeTextEnds = nodeTextEnds;
    }

    /** 获取节点名称模糊查询条件 **/
    public String getNodeTextLike() {
        return nodeTextLike;
    }

    /** 设置节点名称模糊查询条件 **/
    public void setNodeTextLike(String nodeTextLike) {
        this.nodeTextLike = nodeTextLike;
    }

    /** 判断上级编号是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getParentCodeIsNull() {
        return parentCodeIsNull;
    }

    /**
     * 设置上级编号空值查询(true:空值查询|false:非空值查询)
     *
     * @param parentCodeIsNull 上级编号空值查询
     * @deprecated 该字段为非空字段
     */
    @Deprecated
    public void setParentCodeIsNull(Boolean parentCodeIsNull) {
        this.parentCodeIsNull = parentCodeIsNull;
    }

    /** 获取上级编号列表 **/
    public List<String> getParentCodes() {
        return parentCodes;
    }

    /** 设置上级编号列表 **/
    public void setParentCodes(List<String> parentCodes) {
        this.parentCodes = parentCodes;
    }

    /** 增加上级编号 **/
    public void addParentCode(String... parentCodes) {
        if (this.parentCodes == null) {
            this.parentCodes = new ArrayList<>();
        }
        this.parentCodes.addAll(Arrays.asList(parentCodes));
    }

    /** 获取上级编号前模匹配条件 **/
    public String getParentCodeStarts() {
        return parentCodeStarts;
    }

    /** 设置上级编号前模匹配条件 **/
    public void setParentCodeStarts(String parentCodeStarts) {
        this.parentCodeStarts = parentCodeStarts;
    }

    /** 获取上级编号后模匹配条件 **/
    public String getParentCodeEnds() {
        return parentCodeEnds;
    }

    /** 设置上级编号后模匹配条件 **/
    public void setParentCodeEnds(String parentCodeEnds) {
        this.parentCodeEnds = parentCodeEnds;
    }

    /** 获取上级编号模糊查询条件 **/
    public String getParentCodeLike() {
        return parentCodeLike;
    }

    /** 设置上级编号模糊查询条件 **/
    public void setParentCodeLike(String parentCodeLike) {
        this.parentCodeLike = parentCodeLike;
    }

    /** 判断排序号(越小越靠前)是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getSortIndexIsNull() {
        return sortIndexIsNull;
    }

    /**
     * 设置排序号(越小越靠前)空值查询(true:空值查询|false:非空值查询)
     *
     * @param sortIndexIsNull 排序号(越小越靠前)空值查询
     * @deprecated 该字段为非空字段
     */
    @Deprecated
    public void setSortIndexIsNull(Boolean sortIndexIsNull) {
        this.sortIndexIsNull = sortIndexIsNull;
    }

    /** 获取最小排序号(越小越靠前) **/
    public Integer getSortIndexMin() {
        return sortIndexMin;
    }

    /** 设置最小排序号(越小越靠前) **/
    public void setSortIndexMin(Integer sortIndexMin) {
        this.sortIndexMin = sortIndexMin;
    }

    /** 获取最大排序号(越小越靠前) **/
    public Integer getSortIndexMax() {
        return sortIndexMax;
    }

    /** 设置最大排序号(越小越靠前) **/
    public void setSortIndexMax(Integer sortIndexMax) {
        this.sortIndexMax = sortIndexMax;
    }

    /** 判断级数(从1开始)是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getLevelIndexIsNull() {
        return levelIndexIsNull;
    }

    /**
     * 设置级数(从1开始)空值查询(true:空值查询|false:非空值查询)
     *
     * @param levelIndexIsNull 级数(从1开始)空值查询
     * @deprecated 该字段为非空字段
     */
    @Deprecated
    public void setLevelIndexIsNull(Boolean levelIndexIsNull) {
        this.levelIndexIsNull = levelIndexIsNull;
    }

    /** 获取最小级数(从1开始) **/
    public Integer getLevelIndexMin() {
        return levelIndexMin;
    }

    /** 设置最小级数(从1开始) **/
    public void setLevelIndexMin(Integer levelIndexMin) {
        this.levelIndexMin = levelIndexMin;
    }

    /** 获取最大级数(从1开始) **/
    public Integer getLevelIndexMax() {
        return levelIndexMax;
    }

    /** 设置最大级数(从1开始) **/
    public void setLevelIndexMax(Integer levelIndexMax) {
        this.levelIndexMax = levelIndexMax;
    }

    /** 判断是否叶子节点是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getLeafIsNull() {
        return leafIsNull;
    }

    /**
     * 设置是否叶子节点空值查询(true:空值查询|false:非空值查询)
     *
     * @param leafIsNull 是否叶子节点空值查询
     * @deprecated 该字段为非空字段
     */
    @Deprecated
    public void setLeafIsNull(Boolean leafIsNull) {
        this.leafIsNull = leafIsNull;
    }

    /** 判断创建人ID是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getCreatorIdIsNull() {
        return creatorIdIsNull;
    }

    /** 设置创建人ID空值查询(true:空值查询|false:非空值查询) **/
    public void setCreatorIdIsNull(Boolean creatorIdIsNull) {
        this.creatorIdIsNull = creatorIdIsNull;
    }

    /** 获取创建人ID前模匹配条件 **/
    public String getCreatorIdStarts() {
        return creatorIdStarts;
    }

    /** 设置创建人ID前模匹配条件 **/
    public void setCreatorIdStarts(String creatorIdStarts) {
        this.creatorIdStarts = creatorIdStarts;
    }

    /** 获取创建人ID后模匹配条件 **/
    public String getCreatorIdEnds() {
        return creatorIdEnds;
    }

    /** 设置创建人ID后模匹配条件 **/
    public void setCreatorIdEnds(String creatorIdEnds) {
        this.creatorIdEnds = creatorIdEnds;
    }

    /** 获取创建人ID模糊查询条件 **/
    public String getCreatorIdLike() {
        return creatorIdLike;
    }

    /** 设置创建人ID模糊查询条件 **/
    public void setCreatorIdLike(String creatorIdLike) {
        this.creatorIdLike = creatorIdLike;
    }

    /** 获取最小创建时间 **/
    public Date getCreateTimeMin() {
        return createTimeMin;
    }

    /** 设置最小创建时间 **/
    public void setCreateTimeMin(Date createTimeMin) {
        this.createTimeMin = createTimeMin;
    }

    /** 获取最大创建时间 **/
    public Date getCreateTimeMax() {
        return createTimeMax;
    }

    /** 设置最大创建时间 **/
    public void setCreateTimeMax(Date createTimeMax) {
        this.createTimeMax = createTimeMax;
    }

    /** 获取最小创建时间 **/
    public Date getCreateTimeMinWithDay() {
        return createTimeMinWithDay;
    }

    /** 设置最小创建时间 **/
    public void setCreateTimeMinWithDay(Date createTimeMinWithDay) {
        this.createTimeMinWithDay = createTimeMinWithDay;
    }

    /** 获取最大创建时间 **/
    public Date getCreateTimeMaxWithDay() {
        return createTimeMaxWithDay;
    }

    /** 设置最大创建时间 **/
    public void setCreateTimeMaxWithDay(Date createTimeMaxWithDay) {
        this.createTimeMaxWithDay = createTimeMaxWithDay;
    }

    /** 判断选项是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getOptionsIsNull() {
        return optionsIsNull;
    }

    /** 设置选项空值查询(true:空值查询|false:非空值查询) **/
    public void setOptionsIsNull(Boolean optionsIsNull) {
        this.optionsIsNull = optionsIsNull;
    }

    /** 判断启用状态(1.正常|2.未启用)是否为空值查询(true:空值查询|false:非空值查询) **/
    public Boolean getUsingStateIsNull() {
        return usingStateIsNull;
    }

    /**
     * 设置启用状态(1.正常|2.未启用)空值查询(true:空值查询|false:非空值查询)
     *
     * @param usingStateIsNull 启用状态(1.正常|2.未启用)空值查询
     * @deprecated 该字段为非空字段
     */
    @Deprecated
    public void setUsingStateIsNull(Boolean usingStateIsNull) {
        this.usingStateIsNull = usingStateIsNull;
    }

    /** 获取启用状态(1.正常|2.未启用)列表 **/
    public List<UsingState> getUsingStates() {
        return usingStates;
    }

    /** 设置启用状态(1.正常|2.未启用)列表 **/
    public void setUsingStates(List<UsingState> usingStates) {
        this.usingStates = usingStates;
    }

    /** 增加启用状态(1.正常|2.未启用) **/
    public void addUsingState(UsingState... usingStates) {
        if (this.usingStates == null) {
            this.usingStates = new ArrayList<>();
        }
        this.usingStates.addAll(Arrays.asList(usingStates));
    }

}